# #1. 简答题：
#    1. 面向对象的三大特性是什么？
#    2. 什么是面向对象的新式类？什么是经典类？
#    3. 面向对象为什么要有继承？继承的好处是什么？ 重写父类代码
#    4. 面向对象中super的作用。
#
#
#
# 2. 代码题(通过具体代码完成下列要求)：
#
#    ```
#    class A:
#        def func(self):
#            print('in A')
#
#    class B:
#        def func(self):
#            print('in B')
#
#    class C(A,B):
#        def func(self):
#            print('in C')
#    ```
#
# ​		可以改动上上面代码，完成下列需求：对C类实例化一个对象产生一个c1，然后c1.func()
#
# ​		1. 让其执行C类中的func
#
# ​		2. 让其执行A类中的func
#
# ​		3. 让其执行B类中的func
#
# ​		4. 让其既执行C类中的func，又执行A类中的func
#
# ​		5. 让让其既执行C类中的func，又执行B类中的func

# class A:
#    def func(self):
#        print('in A')
#
# class B:
#    def func(self):
#        print('in B')
#
# class C(A,B):
#    def func(self):
#        super(A,self).func()
#        print('in C')
#
# c1 = C()
# c1.func()

#
# 3. 下面代码执行结果是什么？为什么？
#
#    ```
#    class Parent:
#        def func(self):
#            print('in Parent func')
#
#        def __init__(self):
#            self.func()
#
#    class Son(Parent):
#        def func(self):
#            print('in Son func')
#
#    son1 = Son()
#   ```

# class Parent:
#    def func(self):
#        print('in Parent func')
#
#    def __init__(self):
#        self.func()
#
# class Son(Parent):
#    def func(self):
#        print('in Son func')
#
# son1 = Son()


# 4.
#
# ```
# class A:
#     name = []
#
# p1 = A()
# p2 = A()
# # p1.name.append(1)
# # p1.name = 'alex'
# # print(p1.name)
# # print(p2.name)
# # print(A.name)
# # p1.name，p2.name，A.name 分别是什么？
# # 对于类中的公共静态属性如果其是可变的数据类型,对象可以对其增删改查值.
#
# p1.age = 12
# p1.age，p2.age，A.age 分别又是什么？为什么？
# ```
#
# 5. 写出下列代码执行结果：
#
# ```
# class Base1:
#     def f1(self):
#         print('base1.f1')  # 3
#
#     def f2(self):
#         print('base1.f2')
#
#     def f3(self):  # self = obj
#         print('base1.f3')  # 2
#         self.f1()
#
# class Base2:
#     def f1(self):
#         print('base2.f1')
#
# class Foo(Base1, Base2):
#     def f0(self):
#         print('foo.f0')  # 1
#         self.f3()
#
# obj = Foo()
# obj.f0()



# ```
#
# 6. 看代码写结果：
#
# ```
# class Parent:
#     x = 1
#
# class Child1 (Parent):
# 	pass
#
# class Child2(Parent):
# 	pass
#
#
# print(Parent.x,Child1.x,Child2.x)
#
# Child2.x = 2
# print(Parent.x,Child1.x,Child2.x)
#
# Child1.x = 3
# print(Parent.x,Child1.x,Child2.x)
# ```
#
# 7. 有如下类：
#
# ```
# class A:
#     pass
#
# class B(A):
#     pass
#
# class C(A):
#     pass
#
# class D(A):
#     pass
#
# class E(B,C):
#     pass
#
# class F(C,D):
#     pass
#
# class G(D):
#     pass
#
# class H(E,F):
#     pass
#
# class I(F,G):
#     pass
#
# class K(H,I):
#     pass
# ```
#
# 如果这是经典类，请写出他的继承顺序。
#
# 如果这是新式类，请写出他的继承顺序，并写出具体过程。
"""
1. 暴力摩托程序（完成下列需求）：

   1. 创建三个游戏人物，分别是：

      ​	苍井井，女，18，攻击力ad为20，血量200

      ​	东尼木木，男，20，攻击力ad为30，血量150

      ​	波多多，女，19，攻击力ad为50，血量80

   2. 创建三个游戏武器，分别是：

      ​  平底锅，ad为20

      ​	斧子，ad为50

      ​	双节棍，ad为65

   3. 创建三个游戏摩托车，分别是：

​	小踏板，速度60迈

​        雅马哈，速度80迈

​        宝马，速度120迈。

​    完成下列需求（利用武器打人掉的血量为武器的ad + 人的ad）：

​	（1）苍井井骑着小踏板开着60迈的车行驶在赛道上。

​	（2）东尼木木骑着宝马开着120迈的车行驶在赛道上。

​	（3）波多多骑着雅马哈开着80迈的车行驶在赛道上。

​	（4）苍井井赤手空拳打了波多多20滴血，波多多还剩xx血。

​	（5）东尼木木赤手空拳打了波多多30滴血，波多多还剩xx血。

​	（6）波多多利用平底锅打了苍井井一平底锅，苍井井还剩xx血。

​	（7）波多多利用斧子打了东尼木木一斧子，东尼木木还剩xx血。

​	（8）苍井井骑着宝马打了骑着小踏板的东尼木木一双节棍，东尼木木哭了，还剩xx血。（选做）

​	（9）波多多骑着小踏板打了骑着雅马哈的东尼木木一斧子，东尼木木哭了，还剩xx血。（选做）


"""
class Role():

    def __init__(self, name, sex, age, ad, hp):
        self.name = name
        self.sex = sex
        self.age = age
        self.ad = ad
        self.hp = hp

    def equit_Moto(self,Moto):
        self.Moto = Moto

    def equit_weapon(self,wea):
        self.wea = wea
class Weapon():

    def __init__(self, name, ad):
        self.name = name
        self.ad = ad

    def weapon_attack(self,p1,p2):
        p2.hp = p2.hp - p1.ad - self.ad
        print(f'{p1.name}利用{self.name}打了{p2.name}一{self.name}，{p2.name}还剩{p2.hp}血')

class Moto():

    def __init__(self,name,speed):
        self.name=name
        self.speed=speed

    def drive(self,p1):
        print(f'{p1.name}骑着{self.name}开着{self.speed}的车行驶在赛道上')

r1 = Role('苍井井', '女', '18', 20, 200)
r2 = Role('东尼木木', '男', '20', 30, 150)
r3 = Role('波多多', '女', '19', 50, 80)

w1 = Weapon('平底锅', 20)
w2 = Weapon('斧子', 50)
w3 = Weapon('双节棍', 65)

c1 = Moto('小踏板', '60迈')
c2 = Moto('雅马哈', '80迈')
c3 = Moto('川崎', '120迈')

# r1.equit_Moto(c1)
# r1.Moto.drive(r1)

r3.equit_weapon(w1)
r3.wea.weapon_attack(r3, r1)
